package com.jxd.gateway.filter;

import com.jxd.constant.JwtClaimsConstant;
import com.jxd.context.BaseContext;
import com.jxd.gateway.config.SwitchProperties;
import com.jxd.gateway.properties.JwtProperties;
import com.jxd.utils.AesUtil;
import com.jxd.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;

import org.springframework.http.HttpStatus;
import org.springframework.http.server.RequestPath;
import org.springframework.http.server.reactive.ServerHttpRequest;

import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.sql.PreparedStatement;
import java.util.*;

// @Order(-1) // 这个注解可以替代下面的getOrder方法
@Component
@Slf4j
public class AuthorizeFilter implements GlobalFilter, Ordered {
    @Autowired
    private JwtProperties jwtProperties;
    @Autowired
    private SwitchProperties switchProperties;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求路径
        ServerHttpRequest request = exchange.getRequest();
        RequestPath path = request.getPath();
        System.out.println("看这里path:" + path);
        if (path.toString().equals("/users/login")){
            return chain.filter(exchange);
        }
//获取请求参数



//        if (switchProperties.getAes()==1) {
//            MultiValueMap<String, String> queryParams = request.getQueryParams();
//            Set<Map.Entry<String, List<String>>> entries = queryParams.entrySet();
//            for (Map.Entry<String, List<String>> entry : entries) {
//                List<String> values = entry.getValue();
//                for (String value : values) {
//                    try {
//                        String secretKey = AesUtil.getSecretKey();
//                          AesUtil.decryptWithIV(value, secretKey);
//                    } catch (Exception e) {
//                        throw new RuntimeException(e);
//                    }
//
//
//                }
//            }
//        }
        if ("1".equals(switchProperties.getAes())) {
            MultiValueMap<String, String> queryParams = request.getQueryParams();
            MultiValueMap<String, String> decryptedParams = new LinkedMultiValueMap<>();
            queryParams.forEach((key, values) -> {
                List<String> decryptedValues = new ArrayList<>();
                for (String value : values) {
                    try {
                        if (StringUtils.hasText(value)) { // 确保值不为空
                            String secretKey = AesUtil.getSecretKey(); // 假设这是获取密钥的方法
                            value = AesUtil.decryptWithIV(value, secretKey); // 解密逻辑
                        }
                        decryptedValues.add(value);
                    } catch (IllegalArgumentException e) {

                        // 如果是因为长度问题导致的异常，可以记录日志或做相应处理
                        log.error("Failed to decrypt parameter {}: {}", key, e.getMessage());
                        // 根据实际情况决定是否添加原始加密值或直接忽略
                        decryptedValues.add(value); // 这里选择保留原样，实际中可能需要更细致的处理
                    } catch (Exception e) {
//                        // 其他异常处理
////                        log.error("Unexpected error while decrypting parameter {}: {}", key, e.getMessage());
//                        // 可能需要中断过滤链或采取其他恢复措施
//                        return Mono.error(e);
                    }
                }
                decryptedParams.put(key, decryptedValues);
            });

            // 替换原来的请求参数
//            ServerHttpRequest newRequest = request.mutate()
//                    .uri(builder -> builder.queryParams(decryptedParams).build())
//                    .build();

        // 如果不需要解密或没有开关头，直接传递给下一个过滤器
        return chain.filter(exchange);
    }
//        // 2.获取请求头中的 authorization（token）
//        String token = request.getHeaders().getFirst(jwtProperties.getUserTokenName());
//        String aSwitch = request.getHeaders().getFirst("switch");
//        if (aSwitch.equals("1")){
//            return chain.filter(exchange);
//        }
//        ServerHttpResponse response = exchange.getResponse();
//
//
//        if(!StringUtils.hasLength(token)){
//            // token为空 不通过，响应401状态码
//            response.setStatusCode(HttpStatus.UNAUTHORIZED);
//            return response.setComplete();
//        }
        //2、校验令牌
        try {
//            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
//            log.info("当前用户id：{}", userId);
            // 把当前用户的id保存到当前的线程中
            BaseContext.setCurrentId(userId);
            //3、通过，放行
           return chain.filter(exchange);
        } catch (Exception ex) {
            ex.printStackTrace();
//            log.error(ex.getMessage(),ex);
            //4、不通过，响应401状态码
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }



    @Override
    public int getOrder() {
        return -1; // 这里是这个全局过滤器的执行顺序 值越小越先执行
    }

}
